// #ifndef __studies_architecture_interacting__login__h__
// #define __studies_architecture_interacting__login__h__



// /** @file */


// /** @todo */

// // ==> C++ Headers
// #include <cstdint>

// // ==> 3rds Headers

// // ==> Our Headers

// // ==> Namespaces
// using namespace std;

// // ==> Macro Constants

// // ==> Macro Commands


// /** ==> namespace of the organization */
// namespace studies {
//     /** ==> namespace for the project */
//     namespace architecture {
//         /** ==> display, interacting, transmitting, message, server, processor,
//             object, storer */ 
//         namespace interacting {

//             // ==> Typedefs 

//             // ==> Pre-Declarations

//             // ==> Attributes 

//             // ==> Functions

//             // ==> Classes

//             /** 
//                 @nosubgrouping 
//             */
//             template <typename t_display, typename t_transmitting>
//             class login {

//                 // ==> login - Friends

//                 /** Class allowed to access private members of @p login, in order
//                     to perform tests */
//                 friend class login_tester;

//             public:

//                 // ==> login - Public Internal Types

//                 /** */
//                 typedef t_transmitting transmitting;

//                 /** */
//                 typedef t_display display;

//                 /** */
//                 enum states : uint16_t {WAITING_FOR_LOGIN, LOGIN_VALID, LOGIN_INVALID};

//                 // ==> login - Public Constructors

//                 /** Destructor */
//                 login( )
//                     : m_transmitting(),
//                       m_state(WAITING_FOR_LOGIN) {}


//                 /** Destructor */
//                 ~login( ) {}

//                 // ==> login - Public Accessors

//                 // ==> login - Public Helpers

//                 // ==> login - Public Processors

//                 /*
//                   using std::placeholders::_1;
//                   m_called.stuff(std::bind(&caller::stuff_done, this, _1), p_i);
//                 */

//                 /** */
//                 bool is_login_valid() const {
//                     return m_state == LOGIN_VALID;
//                 }

//                 /** */
//                 void on_login_set(const std::string & p_login) {
//                     m_state = LOGIN_VALID;
//                 }

//                 /**
//                    @return a string the user defined as his/hers login
//                 */
//                 std::string start_sync() {
                    
//                 }
                

//                 // ==> login - Public Operators

//                 // ==> login - Public Attributes

//             private:

//                 // ==> login - Private Internal Types

//                 // ==> login - Private Constructors

//                 // ==> login - Private Accessors

//                 // ==> login - Private Helpers

//                 // ==> login - Private Processors

//                 // ==> login - Private Operators

//                 // ==> login - Private Attributes

//                 /** */
//                 transmitting m_transmitting;

//                 /** */
//                 states m_state;
                
                
//             };
//         }
//     }
// }

// // =============================================================================
// // I M P L E M E N T A T I O N
// // =============================================================================

// using namespace studies::architecture::interacting;


// #endif
